'use strict';

const advancedPool = require('advanced-pool');
const fs = require('fs');
const path = require('path');
const url = require('url');
const util = require('util');
const zlib = require('zlib');

// sharp has to be required before node-canvas
// see https://github.com/lovell/sharp/issues/371
const sharp = require('sharp');

const { createCanvas } = require('canvas');

const clone = require('clone');
const Color = require('color');
const express = require('express');
const mercator = new (require('@mapbox/sphericalmercator'))();
const mbgl = require('@mapbox/mapbox-gl-native');
const MBTiles = require('@mapbox/mbtiles');
const proj4 = require('proj4');
const request = require('request');

const utils = require('./utils');

const FLOAT_PATTERN = '[+-]?(?:\\d+|\\d+\.?\\d+)';

const getScale = scale => (scale || '@1x').slice(1, 2) | 0;

mbgl.on('message', e => {
  if (e.severity === 'WARNING' || e.severity === 'ERROR') {
    console.log('mbgl:', e);
  }
});

/**
 * Lookup of sharp output formats by file extension.
 */
const extensionToFormat = {
  '.jpg': 'jpeg',
  '.jpeg': 'jpeg',
  '.png': 'png',
  '.webp': 'webp'
};

/**
 * Cache of response data by sharp output format and color.  Entry for empty
 * string is for unknown or unsupported formats.
 */
const cachedEmptyResponses = {
  '': Buffer.alloc(0)
};

/**
 * Create an appropriate mbgl response for http errors.
 * @param {string} format The format (a sharp format or 'pbf').
 * @param {string} color The background color (or empty string for transparent).
 * @param {Function} callback The mbgl callback.
 */
function createEmptyResponse(format, color, callback) {
  if (!format || format === 'pbf') {
    callback(null, {data: cachedEmptyResponses['']});
    return;
  }

  if (format === 'jpg') {
    format = 'jpeg';
  }
  if (!color) {
    color = 'rgba(255,255,255,0)';
  }

  const cacheKey = `${format},${color}`;
  const data = cachedEmptyResponses[cacheKey];
  if (data) {
    callback(null, {data: data});
    return;
  }

  // create an "empty" response image
  color = new Color(color);
  const array = color.array();
  const channels = array.length === 4 && format !== 'jpeg' ? 4 : 3;
  sharp(Buffer.from(array), {
    raw: {
      width: 1,
      height: 1,
      channels: channels
    }
  }).toFormat(format).toBuffer((err, buffer, info) => {
    if (!err) {
      cachedEmptyResponses[cacheKey] = buffer;
    }
    callback(null, {data: buffer});
  });
}

module.exports = (options, repo, params, id, publicUrl, dataResolver) => {
  const app = express().disable('x-powered-by');

  const maxScaleFactor = Math.min(Math.floor(options.maxScaleFactor || 3), 9);
  let scalePattern = '';
  for (let i = 2; i <= maxScaleFactor; i++) {
    scalePattern += i.toFixed();
  }
  scalePattern = `@[${scalePattern}]x`;

  const lastModified = new Date().toUTCString();

  const watermark = params.watermark || options.watermark;

  const styleFile = params.style;
  const map = {
    renderers: [],
    sources: {}
  };

  const existingFonts = {};
  const fontListingPromise = new Promise((resolve, reject) => {
    fs.readdir(options.paths.fonts, (err, files) => {
      if (err) {
        reject(err);
        return;
      }
      for (const file of files) {
        fs.stat(path.join(options.paths.fonts, file), (err, stats) => {
          if (err) {
            reject(err);
            return;
          }
          if (stats.isDirectory()) {
            existingFonts[path.basename(file)] = true;
          }
        });
      }
      resolve();
    });
  });

  let styleJSON;
  const createPool = (ratio, min, max) => {
    const createRenderer = (ratio, createCallback) => {
      const renderer = new mbgl.Map({
        mode: "tile",
        ratio: ratio,
        request: (req, callback) => {
          const protocol = req.url.split(':')[0];
          //console.log('Handling request:', req);
          if (protocol === 'sprites') {
            const dir = options.paths[protocol];
            const file = unescape(req.url).substring(protocol.length + 3);
            fs.readFile(path.join(dir, file), (err, data) => {
              callback(err, { data: data });
            });
          } else if (protocol === 'fonts') {
            const parts = req.url.split('/');
            const fontstack = unescape(parts[2]);
            const range = parts[3].split('.')[0];
            utils.getFontsPbf(
              null, options.paths[protocol], fontstack, range, existingFonts
            ).then(concated => {
              callback(null, { data: concated });
            }, err => {
              callback(err, { data: null });
            });
          } else if (protocol === 'mbtiles') {
            const parts = req.url.split('/');
            const sourceId = parts[2];
            const source = map.sources[sourceId];
            const sourceInfo = styleJSON.sources[sourceId];
            const z = parts[3] | 0,
              x = parts[4] | 0,
              y = parts[5].split('.')[0] | 0,
              format = parts[5].split('.')[1];
            source.getTile(z, x, y, (err, data, headers) => {
              if (err) {
                if (options.verbose) console.log('MBTiles error, serving empty', err);
                createEmptyResponse(sourceInfo.format, sourceInfo.color, callback);
                return;
              }

              const response = {};
              if (headers['Last-Modified']) {
                response.modified = new Date(headers['Last-Modified']);
              }

              if (format === 'pbf') {
                try {
                  response.data = zlib.unzipSync(data);
                } catch (err) {
                  console.log("Skipping incorrect header for tile mbtiles://%s/%s/%s/%s.pbf", id, z, x, y);
                }
                if (options.dataDecoratorFunc) {
                  response.data = options.dataDecoratorFunc(
                    sourceId, 'data', response.data, z, x, y);
                }
              } else {
                response.data = data;
              }

              callback(null, response);
            });
          } else if (protocol === 'http' || protocol === 'https') {
            request({
              url: req.url,
              encoding: null,
              gzip: true
            }, (err, res, body) => {
              const parts = url.parse(req.url);
              const extension = path.extname(parts.pathname).toLowerCase();
              const format = extensionToFormat[extension] || '';
              if (err || res.statusCode < 200 || res.statusCode >= 300) {
                // console.log('HTTP error', err || res.statusCode);
                createEmptyResponse(format, '', callback);
                return;
              }

              const response = {};
              if (res.headers.modified) {
                response.modified = new Date(res.headers.modified);
              }
              if (res.headers.expires) {
                response.expires = new Date(res.headers.expires);
              }
              if (res.headers.etag) {
                response.etag = res.headers.etag;
              }

              response.data = body;
              callback(null, response);
            });
          }
        }
      });
      renderer.load(styleJSON);
      createCallback(null, renderer);
    };
    return new advancedPool.Pool({
      min: min,
      max: max,
      create: createRenderer.bind(null, ratio),
      destroy: renderer => {
        renderer.release();
      }
    });
  };

  const styleJSONPath = path.resolve(options.paths.styles, styleFile);
  styleJSON = clone(require(styleJSONPath));

  const httpTester = /^(http(s)?:)?\/\//;
  if (styleJSON.sprite && !httpTester.test(styleJSON.sprite)) {
    styleJSON.sprite = 'sprites://' +
        styleJSON.sprite
            .replace('{style}', path.basename(styleFile, '.json'))
            .replace('{styleJsonFolder}', path.relative(options.paths.sprites, path.dirname(styleJSONPath)));
  }
  if (styleJSON.glyphs && !httpTester.test(styleJSON.glyphs)) {
    styleJSON.glyphs = `fonts://${styleJSON.glyphs}`;
  }

  for (const layer of (styleJSON.layers || [])) {
    if (layer && layer.paint) {
      // Remove (flatten) 3D buildings
      if (layer.paint['fill-extrusion-height']) {
        layer.paint['fill-extrusion-height'] = 0;
      }
      if (layer.paint['fill-extrusion-base']) {
        layer.paint['fill-extrusion-base'] = 0;
      }
    }
  }

  const tileJSON = {
    'tilejson': '2.0.0',
    'name': styleJSON.name,
    'attribution': '',
    'minzoom': 0,
    'maxzoom': 20,
    'bounds': [-180, -85.0511, 180, 85.0511],
    'format': 'png',
    'type': 'baselayer'
  };
  const attributionOverride = params.tilejson && params.tilejson.attribution;
  Object.assign(tileJSON, params.tilejson || {});
  tileJSON.tiles = params.domains || options.domains;
  utils.fixTileJSONCenter(tileJSON);

  let dataProjWGStoInternalWGS = null;

  const queue = [];
  for (const name of Object.keys(styleJSON.sources)) {
    let source = styleJSON.sources[name];
    const url = source.url;

    if (url && url.lastIndexOf('mbtiles:', 0) === 0) {
      // found mbtiles source, replace with info from local file
      delete source.url;

      let mbtilesFile = url.substring('mbtiles://'.length);
      const fromData = mbtilesFile[0] === '{' &&
        mbtilesFile[mbtilesFile.length - 1] === '}';

      if (fromData) {
        mbtilesFile = mbtilesFile.substr(1, mbtilesFile.length - 2);
        const mapsTo = (params.mapping || {})[mbtilesFile];
        if (mapsTo) {
          mbtilesFile = mapsTo;
        }
        mbtilesFile = dataResolver(mbtilesFile);
        if (!mbtilesFile) {
          console.error(`ERROR: data "${mbtilesFile}" not found!`);
          process.exit(1);
        }
      }

      queue.push(new Promise((resolve, reject) => {
        mbtilesFile = path.resolve(options.paths.mbtiles, mbtilesFile);
        const mbtilesFileStats = fs.statSync(mbtilesFile);
        if (!mbtilesFileStats.isFile() || mbtilesFileStats.size === 0) {
          throw Error(`Not valid MBTiles file: ${mbtilesFile}`);
        }
        map.sources[name] = new MBTiles(mbtilesFile, err => {
          map.sources[name].getInfo((err, info) => {
            if (err) {
              console.error(err);
              return;
            }

            if (!dataProjWGStoInternalWGS && info.proj4) {
              // how to do this for multiple sources with different proj4 defs?
              const to3857 = proj4('EPSG:3857');
              const toDataProj = proj4(info.proj4);
              dataProjWGStoInternalWGS = xy => to3857.inverse(toDataProj.forward(xy));
            }

            const type = source.type;
            Object.assign(source, info);
            source.type = type;
            source.tiles = [
              // meta url which will be detected when requested
              `mbtiles://${name}/{z}/{x}/{y}.${info.format || 'pbf'}`
            ];
            delete source.scheme;

            if (options.dataDecoratorFunc) {
              source = options.dataDecoratorFunc(name, 'tilejson', source);
            }

            if (!attributionOverride &&
                source.attribution && source.attribution.length > 0) {
              if (tileJSON.attribution.length > 0) {
                tileJSON.attribution += '; ';
              }
              tileJSON.attribution += source.attribution;
            }
            resolve();
          });
        });
      }));
    }
  }

  const renderersReadyPromise = Promise.all(queue).then(() => {
    // standard and @2x tiles are much more usual -> default to larger pools
    const minPoolSizes = options.minRendererPoolSizes || [8, 4, 2];
    const maxPoolSizes = options.maxRendererPoolSizes || [16, 8, 4];
    for (let s = 1; s <= maxScaleFactor; s++) {
      const i = Math.min(minPoolSizes.length - 1, s - 1);
      const j = Math.min(maxPoolSizes.length - 1, s - 1);
      const minPoolSize = minPoolSizes[i];
      const maxPoolSize = Math.max(minPoolSize, maxPoolSizes[j]);
      map.renderers[s] = createPool(s, minPoolSize, maxPoolSize);
    }
  });

  repo[id] = tileJSON;

  const tilePattern = `/${id}/:z(\\d+)/:x(\\d+)/:y(\\d+):scale(${scalePattern})?.:format([\\w]+)`;

  const respondImage = (z, lon, lat, bearing, pitch,
                        width, height, scale, format, res, next,
                        opt_overlay) => {
    if (Math.abs(lon) > 180 || Math.abs(lat) > 85.06 ||
      lon !== lon || lat !== lat) {
      return res.status(400).send('Invalid center');
    }
    if (Math.min(width, height) <= 0 ||
      Math.max(width, height) * scale > (options.maxSize || 2048) ||
      width !== width || height !== height) {
      return res.status(400).send('Invalid size');
    }
    if (format === 'png' || format === 'webp') {
    } else if (format === 'jpg' || format === 'jpeg') {
      format = 'jpeg';
    } else {
      return res.status(400).send('Invalid format');
    }

    const pool = map.renderers[scale];
    pool.acquire((err, renderer) => {
      const mbglZ = Math.max(0, z - 1);
      const params = {
        zoom: mbglZ,
        center: [lon, lat],
        bearing: bearing,
        pitch: pitch,
        width: width,
        height: height
      };
      if (z === 0) {
        params.width *= 2;
        params.height *= 2;
      }

      const tileMargin = Math.max(options.tileMargin || 0, 0);
      if (z > 2 && tileMargin > 0) {
        params.width += tileMargin * 2;
        params.height += tileMargin * 2;
      }

      renderer.render(params, (err, data) => {
        pool.release(renderer);
        if (err) {
          console.error(err);
          return;
        }

        const image = sharp(data, {
          raw: {
            width: params.width * scale,
            height: params.height * scale,
            channels: 4
          }
        });

        if (z > 2 && tileMargin > 0) {
          image.extract({
            left: tileMargin * scale,
            top: tileMargin * scale,
            width: width * scale,
            height: height * scale
          });
        }

        if (z === 0) {
          // HACK: when serving zoom 0, resize the 0 tile from 512 to 256
          image.resize(width * scale, height * scale);
        }

        if (opt_overlay) {
          image.composite([{ input: opt_overlay }]);
        }
        if (watermark) {
          const canvas = createCanvas(scale * width, scale * height);
          const ctx = canvas.getContext('2d');
          ctx.scale(scale, scale);
          ctx.font = '10px sans-serif';
          ctx.strokeWidth = '1px';
          ctx.strokeStyle = 'rgba(255,255,255,.4)';
          ctx.strokeText(watermark, 5, height - 5);
          ctx.fillStyle = 'rgba(0,0,0,.4)';
          ctx.fillText(watermark, 5, height - 5);

          image.composite([{ input: canvas.toBuffer() }]);
        }

        const formatQuality = (params.formatQuality || {})[format] ||
          (options.formatQuality || {})[format];

        if (format === 'png') {
          image.png({ adaptiveFiltering: false });
        } else if (format === 'jpeg') {
          image.jpeg({ quality: formatQuality || 80 });
        } else if (format === 'webp') {
          image.webp({ quality: formatQuality || 90 });
        }
        image.toBuffer((err, buffer, info) => {
          if (!buffer) {
            return res.status(404).send('Not found');
          }

          res.set({
            'Last-Modified': lastModified,
            'Content-Type': `image/${format}`
          });
          return res.status(200).send(buffer);
        });
      });
    });
  };

  app.get(tilePattern, (req, res, next) => {
    const modifiedSince = req.get('if-modified-since'), cc = req.get('cache-control');
    if (modifiedSince && (!cc || cc.indexOf('no-cache') === -1)) {
      if (new Date(lastModified) <= new Date(modifiedSince)) {
        return res.sendStatus(304);
      }
    }

    const z = req.params.z | 0,
      x = req.params.x | 0,
      y = req.params.y | 0,
      scale = getScale(req.params.scale),
      format = req.params.format;
    if (z < 0 || x < 0 || y < 0 ||
        z > 20 || x >= Math.pow(2, z) || y >= Math.pow(2, z)) {
      return res.status(404).send('Out of bounds');
    }
    const tileSize = 256;
    const tileCenter = mercator.ll([
      ((x + 0.5) / (1 << z)) * (256 << z),
      ((y + 0.5) / (1 << z)) * (256 << z)
    ], z);
    return respondImage(z, tileCenter[0], tileCenter[1], 0, 0,
                        tileSize, tileSize, scale, format, res, next);
  });

  const extractPathFromQuery = (query, transformer) => {
    const pathParts = (query.path || '').split('|');
    const path = [];
    for (const pair of pathParts) {
      const pairParts = pair.split(',');
      if (pairParts.length === 2) {
        let pair;
        if (query.latlng === '1' || query.latlng === 'true') {
          pair = [+(pairParts[1]), +(pairParts[0])];
        } else {
          pair = [+(pairParts[0]), +(pairParts[1])];
        }
        if (transformer) {
          pair = transformer(pair);
        }
        path.push(pair);
      }
    }
    return path;
  };

  const renderOverlay = (z, x, y, bearing, pitch, w, h, scale,
                         path, query) => {
    if (!path || path.length < 2) {
      return null;
    }
    const precisePx = (ll, zoom) => {
      const px = mercator.px(ll, 20);
      const scale = Math.pow(2, zoom - 20);
      return [px[0] * scale, px[1] * scale];
    };

    const center = precisePx([x, y], z);

    const mapHeight = 512 * (1 << z);
    const maxEdge = center[1] + h / 2;
    const minEdge = center[1] - h / 2;
    if (maxEdge > mapHeight) {
      center[1] -= (maxEdge - mapHeight);
    } else if (minEdge < 0) {
      center[1] -= minEdge;
    }

    const canvas = createCanvas(scale * w, scale * h);
    const ctx = canvas.getContext('2d');
    ctx.scale(scale, scale);
    if (bearing) {
      ctx.translate(w / 2, h / 2);
      ctx.rotate(-bearing / 180 * Math.PI);
      ctx.translate(-center[0], -center[1]);
    } else {
      // optimized path
      ctx.translate(-center[0] + w / 2, -center[1] + h / 2);
    }
    const lineWidth = query.width !== undefined ?
      parseFloat(query.width) : 1;
    ctx.lineWidth = lineWidth;
    ctx.strokeStyle = query.stroke || 'rgba(0,64,255,0.7)';
    ctx.fillStyle = query.fill || 'rgba(255,255,255,0.4)';
    ctx.beginPath();
    for (const pair of path) {
      const px = precisePx(pair, z);
      ctx.lineTo(px[0], px[1]);
    }
    if (path[0][0] === path[path.length - 1][0] &&
      path[0][1] === path[path.length - 1][1]) {
      ctx.closePath();
    }
    ctx.fill();
    if (lineWidth > 0) {
      ctx.stroke();
    }

    return canvas.toBuffer();
  };

  const calcZForBBox = (bbox, w, h, query) => {
    let z = 25;

    const padding = query.padding !== undefined ?
      parseFloat(query.padding) : 0.1;

    const minCorner = mercator.px([bbox[0], bbox[3]], z),
      maxCorner = mercator.px([bbox[2], bbox[1]], z);
    const w_ = w / (1 + 2 * padding);
    const h_ = h / (1 + 2 * padding);

    z -= Math.max(
      Math.log((maxCorner[0] - minCorner[0]) / w_),
      Math.log((maxCorner[1] - minCorner[1]) / h_)
    ) / Math.LN2;

    z = Math.max(Math.log(Math.max(w, h) / 256) / Math.LN2, Math.min(25, z));

    return z;
  };

  if (options.serveStaticMaps !== false) {
    const staticPattern =
      `/${id}/static/:raw(raw)?/%s/:width(\\d+)x:height(\\d+):scale(${scalePattern})?.:format([\\w]+)`;

    const centerPattern =
      util.format(':x(%s),:y(%s),:z(%s)(@:bearing(%s)(,:pitch(%s))?)?',
        FLOAT_PATTERN, FLOAT_PATTERN, FLOAT_PATTERN,
        FLOAT_PATTERN, FLOAT_PATTERN);

    app.get(util.format(staticPattern, centerPattern), (req, res, next) => {
      const raw = req.params.raw;
      let z = +req.params.z,
        x = +req.params.x,
        y = +req.params.y,
        bearing = +(req.params.bearing || '0'),
        pitch = +(req.params.pitch || '0'),
        w = req.params.width | 0,
        h = req.params.height | 0,
        scale = getScale(req.params.scale),
        format = req.params.format;

      if (z < 0) {
        return res.status(404).send('Invalid zoom');
      }

      const transformer = raw ?
        mercator.inverse.bind(mercator) : dataProjWGStoInternalWGS;

      if (transformer) {
        const ll = transformer([x, y]);
        x = ll[0];
        y = ll[1];
      }

      const path = extractPathFromQuery(req.query, transformer);
      const overlay = renderOverlay(z, x, y, bearing, pitch, w, h, scale,
        path, req.query);

      return respondImage(z, x, y, bearing, pitch, w, h, scale, format,
                          res, next, overlay);
    });

    const serveBounds = (req, res, next) => {
      const raw = req.params.raw;
      const bbox = [+req.params.minx, +req.params.miny,
        +req.params.maxx, +req.params.maxy];
      let center = [(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2];

      const transformer = raw ?
        mercator.inverse.bind(mercator) : dataProjWGStoInternalWGS;

      if (transformer) {
        const minCorner = transformer(bbox.slice(0, 2));
        const maxCorner = transformer(bbox.slice(2));
        bbox[0] = minCorner[0];
        bbox[1] = minCorner[1];
        bbox[2] = maxCorner[0];
        bbox[3] = maxCorner[1];
        center = transformer(center);
      }

      const w = req.params.width | 0,
        h = req.params.height | 0,
        scale = getScale(req.params.scale),
        format = req.params.format;

      const z = calcZForBBox(bbox, w, h, req.query),
        x = center[0],
        y = center[1],
        bearing = 0,
        pitch = 0;

      const path = extractPathFromQuery(req.query, transformer);
      const overlay = renderOverlay(z, x, y, bearing, pitch, w, h, scale,
        path, req.query);
      return respondImage(z, x, y, bearing, pitch, w, h, scale, format,
        res, next, overlay);
    };

    const boundsPattern =
      util.format(':minx(%s),:miny(%s),:maxx(%s),:maxy(%s)',
        FLOAT_PATTERN, FLOAT_PATTERN, FLOAT_PATTERN, FLOAT_PATTERN);

    app.get(util.format(staticPattern, boundsPattern), serveBounds);

    app.get(`/${id}/static/`, (req, res, next) => {
      for (let key in req.query) {
        req.query[key.toLowerCase()] = req.query[key];
      }
      req.params.raw = true;
      req.params.format = (req.query.format || 'image/png').split('/').pop();
      const bbox = (req.query.bbox || '').split(',');
      req.params.minx = bbox[0];
      req.params.miny = bbox[1];
      req.params.maxx = bbox[2];
      req.params.maxy = bbox[3];
      req.params.width = req.query.width || '256';
      req.params.height = req.query.height || '256';
      if (req.query.scale) {
        req.params.width /= req.query.scale;
        req.params.height /= req.query.scale;
        req.params.scale = `@${req.query.scale}`;
      }

      return serveBounds(req, res, next);
    });

    const autoPattern = 'auto';

    app.get(util.format(staticPattern, autoPattern), (req, res, next) => {
      const raw = req.params.raw;
      const w = req.params.width | 0,
        h = req.params.height | 0,
        bearing = 0,
        pitch = 0,
        scale = getScale(req.params.scale),
        format = req.params.format;

      const transformer = raw ?
        mercator.inverse.bind(mercator) : dataProjWGStoInternalWGS;

      const path = extractPathFromQuery(req.query, transformer);
      if (path.length < 2) {
        return res.status(400).send('Invalid path');
      }

      const bbox = [Infinity, Infinity, -Infinity, -Infinity];
      for (const pair of path) {
        bbox[0] = Math.min(bbox[0], pair[0]);
        bbox[1] = Math.min(bbox[1], pair[1]);
        bbox[2] = Math.max(bbox[2], pair[0]);
        bbox[3] = Math.max(bbox[3], pair[1]);
      }

      const bbox_ = mercator.convert(bbox, '900913');
      const center = mercator.inverse(
        [(bbox_[0] + bbox_[2]) / 2, (bbox_[1] + bbox_[3]) / 2]
      );

      const z = calcZForBBox(bbox, w, h, req.query),
        x = center[0],
        y = center[1];

      const overlay = renderOverlay(z, x, y, bearing, pitch, w, h, scale,
        path, req.query);

      return respondImage(z, x, y, bearing, pitch, w, h, scale, format,
                          res, next, overlay);
    });
  }

  app.get(`/${id}.json`, (req, res, next) => {
    const info = clone(tileJSON);
    info.tiles = utils.getTileUrls(req, info.tiles,
                                   `styles/${id}`, info.format, publicUrl);
    return res.send(info);
  });

  return Promise.all([fontListingPromise, renderersReadyPromise]).then(() => app);

};
